/**
 * ComposeMiddleware 使用示例
 * 演示如何组合多个中间件来处理业务逻辑
 */

const { ComposeMiddleware } = require('../compose.middleware');
const { UnifiedAuthMiddleware } = require('../auth.middleware');

/**
 * 示例1：基础中间件组合
 * 演示如何组合自定义中间件
 */

// 自定义中间件1：日志记录中间件
function loggingMiddleware(next) {
    return async function() {
        const context = this;
        console.log(`[${new Date().toISOString()}] 请求开始:`, context.params);
        
        const startTime = Date.now();
        const result = await next();
        const endTime = Date.now();
        
        console.log(`[${new Date().toISOString()}] 请求结束，耗时: ${endTime - startTime}ms`);
        return result;
    };
}

// 自定义中间件2：参数验证中间件
function validationMiddleware(next) {
    return async function() {
        const context = this;
        
        // 验证必需参数
        if (!context.params.productId) {
            return { code: 400, message: '缺少productId参数' };
        }
        
        if (!context.params.productName) {
            return { code: 400, message: '缺少productName参数' };
        }
        
        return await next();
    };
}

// 业务处理函数：商品创建
async function createProductHandler() {
    const context = this;
    
    console.log('执行业务逻辑：创建商品');
    
    // 模拟创建商品逻辑
    const product = {
        id: context.params.productId,
        name: context.params.productName,
        price: context.params.price || 0,
        createdAt: new Date()
    };
    
    return {
        code: 200,
        message: '商品创建成功',
        data: product
    };
}

// 组合中间件：日志 + 验证 + 业务逻辑
const createProductWithMiddleware = ComposeMiddleware.createMiddlewareWrapper(
    createProductHandler,
    [loggingMiddleware, validationMiddleware]
);

/**
 * 示例2：认证权限组合
 * 使用 createAuthPermissionWrapper 简化权限控制
 */

// 业务处理函数：获取商品列表
async function getProductListHandler() {
    const context = this;
    
    console.log('执行业务逻辑：获取商品列表');
    
    // 模拟获取商品列表
    const products = [
        { id: '1', name: '商品1', price: 100 },
        { id: '2', name: '商品2', price: 200 }
    ];
    
    return {
        code: 200,
        message: '获取商品列表成功',
        data: products
    };
}

// 需要登录权限的商品列表接口
const getProductListWithAuth = ComposeMiddleware.createAuthPermissionWrapper(
    getProductListHandler,
    { requireLogin: true }
);

// 需要管理员权限的商品管理接口
const adminProductHandler = ComposeMiddleware.createAuthPermissionWrapper(
    createProductHandler,
    {
        requireLogin: true,
        requireRole: 'admin',
        requirePermission: 'product:create'
    }
);

/**
 * 示例3：复杂中间件组合
 * 组合认证、权限、日志、验证等多个中间件
 */

// 业务处理函数：更新商品信息
async function updateProductHandler() {
    const context = this;
    
    console.log('执行业务逻辑：更新商品信息');
    
    // 模拟更新商品逻辑
    const updatedProduct = {
        id: context.params.productId,
        name: context.params.productName,
        updatedAt: new Date()
    };
    
    return {
        code: 200,
        message: '商品更新成功',
        data: updatedProduct
    };
}

// 创建复杂的中间件组合
const complexMiddlewares = [
    loggingMiddleware,  // 日志记录
    validationMiddleware,  // 参数验证
    UnifiedAuthMiddleware.createAuthMiddleware({  // 认证和权限验证
        requireLogin: true,
        requirePermission: 'product:edit'
    })
];

const updateProductWithComplexMiddleware = ComposeMiddleware.createMiddlewareWrapper(
    updateProductHandler,
    complexMiddlewares
);

/**
 * 示例4：错误处理中间件
 * 演示如何处理中间件链中的错误
 */

// 错误处理中间件
function errorHandlingMiddleware(next) {
    return async function() {
        try {
            return await next();
        } catch (error) {
            console.error('中间件执行出错:', error);
            return {
                code: 500,
                message: '服务器内部错误',
                data: null
            };
        }
    };
}

// 业务处理函数：删除商品（可能抛出异常）
async function deleteProductHandler() {
    const context = this;
    
    // 模拟可能抛出异常的业务逻辑
    if (Math.random() > 0.5) {
        throw new Error('模拟的业务异常');
    }
    
    console.log('执行业务逻辑：删除商品');
    
    return {
        code: 200,
        message: '商品删除成功',
        data: { productId: context.params.productId }
    };
}

// 组合错误处理中间件
const deleteProductWithErrorHandling = ComposeMiddleware.createMiddlewareWrapper(
    deleteProductHandler,
    [errorHandlingMiddleware, loggingMiddleware]
);

/**
 * 演示函数：测试所有示例
 */
async function demonstrateComposeMiddleware() {
    console.log('=== ComposeMiddleware 使用示例演示 ===\n');
    
    // 模拟上下文对象
    const mockContext = {
        params: {
            productId: 'prod_123',
            productName: '示例商品',
            price: 100
        },
        result: null
    };
    
    // 测试1：基础中间件组合
    console.log('1. 测试基础中间件组合:');
    try {
        const result1 = await createProductWithMiddleware.call(mockContext);
        console.log('结果:', result1);
    } catch (error) {
        console.log('错误:', error.message);
    }
    
    console.log('\n2. 测试认证权限组合:');
    
    // 测试2：无token情况（应该失败）
    const mockContextNoToken = { ...mockContext };
    try {
        const result2 = await getProductListWithAuth.call(mockContextNoToken);
        console.log('无token结果:', result2);
    } catch (error) {
        console.log('无token错误:', error.message);
    }
    
    // 测试3：有token情况
    const mockContextWithToken = {
        ...mockContext,
        uniIdToken: 'valid_token'
    };
    try {
        const result3 = await getProductListWithAuth.call(mockContextWithToken);
        console.log('有token结果:', result3);
    } catch (error) {
        console.log('有token错误:', error.message);
    }
    
    console.log('\n3. 测试错误处理中间件:');
    try {
        const result4 = await deleteProductWithErrorHandling.call(mockContext);
        console.log('错误处理结果:', result4);
    } catch (error) {
        console.log('错误处理错误:', error.message);
    }
    
    console.log('\n=== 演示结束 ===');
}

// 导出所有示例函数
module.exports = {
    createProductWithMiddleware,
    getProductListWithAuth,
    adminProductHandler,
    updateProductWithComplexMiddleware,
    deleteProductWithErrorHandling,
    demonstrateComposeMiddleware,
    
    // 中间件函数（可用于其他组合）
    loggingMiddleware,
    validationMiddleware,
    errorHandlingMiddleware
};